katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2303

• build_po_modify_ui reuses _render_preview_header, but that helper hard-codes create-card wording (title suffix "Created" and state badge "CREATED"). In applied modify/delete/correct flows this will render incorrect UI copy (e.g., "Modify Purchase Order Created"). Consider adding a modify-aware header helper or making _render_preview_header accept the applied-state label/title suffix (e.g., APPLIED/DELETED/CORRECTED).

        _render_preview_header(
            title_prefix=f"{verb_label} Purchase Order",
            entity="purchase_order",
            order_number=str(entity.get("order_number") or entity_id or "N/A"),
            status=entity.get("status"),
            extra_badges=extra_badges,
        )

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2330

• build_po_modify_ui calls _render_preview_footer, whose applied-state message is always "{title_prefix} created.". With title_prefix=f"Purchase Order {verb_label}" this produces incorrect text like "Purchase Order Delete created." on applied cards. This likely needs a modify-specific footer message (applied/delete/correct) or a parameter to _render_preview_footer to customize the applied-state copy for non-create operations.

        _render_preview_footer(
            title_prefix=f"Purchase Order {verb_label}",
            block_warnings=block_warnings,
            confirm_label=confirm_label,
            apply_action=apply_action,
            cancel_action=cancel_action,
            # No next-action buttons on modify cards by default — the
            # user already had the PO they wanted to change; surfacing
            # "Receive Items" here would be noise. Delete operations
            # also have nothing useful to suggest (the PO is gone).
            next_action_buttons=(),
        )

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2271

• entity = {**prior_state, **{k: v for k, v in response.items() if v is not None}} assumes the response dict contains the post-change PO fields. But to_tool_result() passes ModificationResponse.model_dump(), and ModificationResponse does not include PO fields like status, supplier_name, order_number, etc. As a result, applied cards will continue to show the prior status/order/supplier in the header/body unless you explicitly compute a post-state by applying changes_by_field[*].after onto prior_state (or otherwise supply the post-state).

    verb_label = _verb_label(confirm_tool)
    # Compose the entity view's source-of-truth dict by overlaying the
    # response on top of prior_state. Preview: prior_state is the full
    # pre-change snapshot; response-level scalars (warnings, katana_url)
    # win. Applied: the response carries the post-change scalars too —
    # the same overlay yields the post-change entity, modulo nested
    # collections which the dispatcher already updated.
    entity = {**prior_state, **{k: v for k, v in response.items() if v is not None}}
    # ``entity_id`` from the response is the PO's identity; surface it
    # under the same key the create-card pattern uses so the header
    # Badge picks it up regardless of which payload populated it.
    if entity_id is not None:
        entity.setdefault("id", entity_id)

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2251

• build_po_modify_ui depends on response["prior_state"] for rendering the PO entity view (supplier/location/metrics). However run_modify_plan() currently does not populate prior_state on the preview path (it only sets it on apply), so real modify_purchase_order previews will render without those entity fields. Either include a serialized prior_state in preview ModificationResponse when existing is available, or adjust this builder to explicitly handle the missing-prior_state case (e.g., render only diff lines + a warning).

    actions = response.get("actions") or []
    is_preview = bool(response.get("is_preview", True))
    entity_id = response.get("entity_id")
    prior_state = response.get("prior_state") or {}
    # Note: katana_url is read from RESULT via the Prefab template

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2316

• _summarize_apply_outcome returns (state_label, badge_variant) but current call sites only use [0], and the computed badge_variant is not applied anywhere. Either drop the unused return value (return just the label) or wire the variant into _render_preview_header (e.g., via an applied_state_variant parameter) so FAILED/PARTIAL FAILURE can render as destructive as intended.

    """Bucket a modify response's action outcomes for the header Badge.

    Returns ``(state_label, badge_variant)``. Variants align with the
    create-card Tier 1 vocabulary (``default`` / ``secondary`` /
    ``destructive`` / ``outline``).

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2481

• In the direct-apply (preview → Confirm) flow, the iframe keeps the original Prefab tree and only updates state via SetState("result", RESULT) + SetState("applied", True). However, this card’s body is rendered from the initial response/entity/changes_by_field, so after apply it will still show the preview response["message"] and preview-time diffs, and it cannot surface apply-time failures (✗ + error) because changes_by_field was computed from preview actions (succeeded=None). To make applied/partial-failure UI accurate in the in-place morph path, render applied-state content from state.result (or populate dedicated state fields in extra_on_success) and switch the body/message/diff source when applied is true.

        with CardContent(), Column(gap=3):
            if response.get("message"):
                Muted(content=response["message"])
            block_warnings = _render_po_entity_view(entity, changes=changes_by_field)
        # Confirm label scales with the number of planned actions —

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2466

• On the standalone-applied path, _summarize_apply_outcome(actions) can set the state badge to FAILED/PARTIAL FAILURE, but the title suffix and footer verb remain hardcoded to "Applied"/"applied" for modify/correct. That makes the card read e.g. "Modify Purchase Order Applied" and "… applied." even when the outcome is FAILED, which is misleading. Consider deriving the applied title/footer copy from the same outcome summary (at least for full failure) so the user-visible text stays consistent with the header badge.

        else:
            applied_title_suffix = "Applied"
            applied_state_label = "APPLIED"
            applied_verb = "applied"
        applied_state_variant = "default"

        # On the standalone-applied path (is_preview=False), let the
        # actual outcome drive both the state label AND the badge
        # variant — so a fully-failed apply reads "FAILED" with the
        # destructive (red) variant, not "APPLIED" with the success
        # (green) variant. Partial failures also surface in the
        # destructive variant. The in-place morph path can't know the
        # outcome at build time, so it keeps APPLIED/DELETED + default
        # — failed actions there surface via the per-field ✗ glyphs.
        if not is_preview:
            outcome_label, outcome_variant = _summarize_apply_outcome(actions)
            if outcome_label != "APPLIED":
                applied_state_label = outcome_label
                applied_state_variant = outcome_variant

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2165

• _render_po_entity_view reads PO fields using the create-card response shape (total_cost, item_count, etc.). But ModificationResponse.prior_state is serialized from the Katana API model (RegularPurchaseOrder.to_dict()), which uses different keys (e.g. total, purchase_order_rows, additional_info, order_no, nested supplier). As a result, real modify/delete/correct cards will likely omit the Total/Line Items metrics (and other context) even when prior_state is present. Consider normalizing the PO snapshot into the create-card field names (or add fallbacks like total_cost or total and derive item_count from purchase_order_rows) before rendering.

    changes = changes or {}
    total_cost = entity.get("total_cost")
    currency = entity.get("currency")
    item_count = entity.get("item_count")

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2472

• build_po_modify_ui renders the header order-number and status from entity.get("order_number") / entity.get("status"), but the entity dict is primarily composed from prior_state and does not apply actions[*].changes to compute the post-change values. This contradicts the inline comment in _render_po_entity_view that status changes “already surface in the Tier 1 header Badge”, and can cause the header badge(s) to show the pre-change status/number while the body diff shows the new value. Consider deriving header fields from changes_by_field when present (e.g. status_change.after, order_no/order_number change.after) and falling back to the snapshot only when no diff is available.

        _render_preview_header(
            title_prefix=f"{verb_label} Purchase Order",
            entity="purchase_order",
            order_number=str(entity.get("order_number") or entity_id or "N/A"),
            status=entity.get("status"),

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:1417

• The module comment says failed fields render a leading ✗ plus an inline error line, but the implementation aggregates error messages into the bottom Alert via _render_failed_changes_block (and explicitly avoids inline error text). Please update this comment to match the actual rendering behavior to avoid misleading future maintainers.

This issue also appears in the following locations of the same file:

• line 1541
• line 2516

]


def _format_qty_change(qty: float) -> str:
    """Format a quantity change with leading sign (e.g., ``+1.0``, ``-3.5``)."""
    return f"{qty:+.1f}"

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:1546

• _render_field_diff_line docstring describes rendering an inline Muted error line when change.failed is True, but the function intentionally does not render inline error text (errors are consolidated in _render_failed_changes_block). Update the docstring to reflect the actual behavior.

    parent action's ``succeeded`` / ``error`` so failed actions surface
    per-field on every field they were going to write. A field appearing
    in two actions (rare) takes the last write — the iteration order
    matches the action plan's execution order, so the last write is the
    one that ran (or would have run) most recently.
    """

katana_mcp_server/src/katana_mcp/tools/prefab_ui.py:2521

• build_po_modify_ui docstring says failed fields show a leading ✗ glyph + inline error, but errors are actually consolidated into the bottom Alert block. Updating this docstring would keep the documented contract consistent with the renderer.

        with CardContent(), Column(gap=3):
            block_warnings = _render_po_entity_view(response)
        _render_preview_footer(
            title_prefix="Purchase Order",
            block_warnings=block_warnings,
            confirm_label="Confirm & Create Purchase Order",